<?xml version="1.0" encoding="UTF-8"?>
<html>
    <head>
        <link type="text/css" rel="stylesheet" href="./css/template.css" />
        <link type="text/css" rel="stylesheet" href="./css/SyntaxHighlighter.css" />
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Qu'est-ce que J2ME ?</title>
        <script language="javascript" src="./js/shInit.js" />
        <script language="javascript" src="./js/shCore.js" />
        <script language="javascript" src="./js/shBrushCpp.js" />
        <script language="javascript" src="./js/shBrushCSharp.js" />
        <script language="javascript" src="./js/shBrushCss.js" />
        <script language="javascript" src="./js/shBrushDelphi.js" />
        <script language="javascript" src="./js/shBrushJava.js" />
        <script language="javascript" src="./js/shBrushJScript.js" />
        <script language="javascript" src="./js/shBrushPhp.js" />
        <script language="javascript" src="./js/shBrushPython.js" />
        <script language="javascript" src="./js/shBrushRuby.js" />
        <script language="javascript" src="./js/shBrushSql.js" />
        <script language="javascript" src="./js/shBrushVb.js" />
        <script language="javascript" src="./js/shBrushXml.js" />
        <keywords>J2ME</keywords>
        <author>Fabrice GRONDIN</author>
        <keywords>J2ME,java,micro,edition,sun</keywords>
    </head>
    <body>
        <div class="chapter">
            <h2>1. Introduction</h2>
            <p>On connaît principalement Java en tant qu'environnement de programmation pour serveurs, centré autour des technologies qui ont permis de réaliser Java 2 Enterprise Edition (J2EE), telles que les Enterprise JavaBeans (EJBs), les Servlets, et les JavaServer Pages (JSP). Néanmoins, ce langage avait initialement été conçu en tant qu'environnement pour des applications "côté-client". En fait, Java avait été conçu pour les appareils ménagers. Et maintenant, avec Java 2 Micro Edition, J2ME en abrégé, Java retourne à ses sources.</p>
        </div>
        <div class="chapter">
            <h2>2. Qu’est-ce que Java 2 Micro Edition ?</h2>
            <p>
                J2ME ou
                <strong>Java 2 Micro Edition</strong>
                est l'édition de la plateforme Java 2 à destination de l'électronique grand public et des systèmes embarqués.
                <br />
                Les terminaux n’ayant pas les même capacités en terme de ressources que les ordinateurs de bureau classiques (mémoire, disque et puissance de calcul), la solution passe par la fourniture d’un environnement allégé afin de s’adapter aux différentes contraintes d’exécution.
                <br />
                <strong>J2ME</strong>
                est donc, le framework
                <strong>Java</strong>
                spécialisé dans les applications mobiles. Des plates-formes Java compatibles avec J2ME sont embarquées dans de nombreux
                <u>téléphones portables</u>
                et
                <u>PDA</u>
                .
                <br />
                <br />
                Une plate-forme J2ME est composée :
                <br />
            </p>
            <ul>
                <li>
                    d’une « machine virtuelle » capable d'exécuter une application Java, elle pourra être allégée afin de consommer plus ou moins de ressources (
                    <strong>KVM</strong>
                    ou Kilobyte Virtual Machine,
                    <strong>CVM</strong>
                    ou C-Virtual Machine, …).
                </li>
                <li>d'une « configuration », une API donnant accès aux fonctions de base du système.</li>
                <li>d'un « profil », une API donnant accès aux fonctions spécifiques de la plate forme.</li>
            </ul>
            <br />
            <img src="images/j2me_html_154678a8.png" alt="" width="100%" />
        </div>
        <div class="chapter">
            <h2>3. Les configurations</h2>
            <p>
                La configuration représente le
                <strong>socle de J2ME</strong>
                . Elle est constituée de la machine virtuelle et des librairies bas niveaux. Il existe actuellement deux types de configurations : CDC et CLDC.
				Leur utilisation est en fonction du type de matériel où s'exécutera l'environnement Java. Les configurations sont empilables, de sorte que ce qui est prévu pour s'exécuter sur une configuration CLDC peut s'exécuter sur une configuration CDC. En revanche, la réciproque n'est pas vraie.
            </p>
            <div class="subChapter">
                <h3>3.1. La CDC (Connected Device Configuration)</h3>
                <p>
                    La
                    <strong>CDC</strong>
                    est plus adaptée aux terminaux relativement puissants comme les PDA. En effet, elle nécessite une machine virtuelle java optimisée appelée CVM qui offre les même fonctionnalités que la JVM classique.
                    <br />
                    <br />
                    Les caractéristiques de l’environnement matériel proposé par la configuration CDC sont :
                    <br />
                </p>
                <ul>
                    <li>
                        Minimum de
                        <strong>512Ko</strong>
                        de ROM et
                        <strong>256Ko</strong>
                        de RAM, processeur
                        <strong>32 bits</strong>
                    </li>
                    <li>
                        <strong>Une connexion réseau obligatoire</strong>
                        (sans fil ou pas)
                    </li>
                    <li>Support des spécifications complètes de la machine virtuelle Java (CVM)</li>
                </ul>
            </div>
            <div class="subChapter">
                <h3>
                    3.2. La
                    <strong>CLDC</strong>
                    (Connected Limited Device Configuration)
                </h3>
                <p>
                    La CLDC est, par contre, dédiée aux appareils avec de faibles capacités comme les téléphones portables, les assistants personnels, ou les périphériques légers sans fil.
					La machine virtuelle allégée correspondante est la KVM et ne possède pas certaines fonctions de la JVM classique.
                    <br />
                    <br />
                    La liste suivante résume l’ensemble de ces caractéristiques :
                    <br />
                </p>
                <ul>
                    <li>
                        Minimum de
                        <strong>160Ko à 512Ko</strong>
                        de RAM, processeur
                        <strong>16 ou 32 bits</strong>
                        , vitesse
                        <strong>16Mhz</strong>
                        ou plus
                    </li>
                    <li>
                        <strong>Alimentation limitée</strong>
                        , prise en charge d’une batterie.
                    </li>
                    <li>
                        <strong>Connexion réseau non permanente</strong>
                        , sans fil.
                    </li>
                    <li>Interface graphique limitée ou inexistante.</li>
                </ul>
                <u>Vue d’ensemble de l’API :</u>
                <br />
                <ul>
                    <li>
                        Le package
                        <strong>java.lang</strong>
                        est un sous-ensemble des classes standards du package java.lang de J2SE.
                    </li>
                    <li>
                        Le package
                        <strong>java.io</strong>
                        contient les méthodes nécessaires pour récupérer des informations des systèmes distants c'est-à-dire gestion des flux d’entrées/sorties.
                    </li>
                    <li>
                        Le package
                        <strong>java.util</strong>
                        contient un petit sous-ensemble du package correspondant de J2SE, dont voici les classes retenues :
                        <strong>Calendar</strong>
                        ,
                        <strong>Date</strong>
                        ,
                        <strong>TimeZone</strong>
                        ,
                        <strong>Enumeration</strong>
                        ,
                        <strong>Vector</strong>
                        ,
                        <strong>Stack</strong>
                        ,
                        <strong>Hashtable</strong>
                        et
                        <strong>Random</strong>
                        .
                    </li>
                    <li>
                        Le principal objet du package
                        <strong>javax.microedition.io</strong>
                        est la classe
                        <strong>Connector</strong>
                        permettant d’effectuer des entrées/sorties.
                    </li>
                </ul>
            </div>
        </div>
        <div class="chapter">
            <h2>4. Les profils</h2>
            <p>
                Une configuration définit le fondement d'une application, un
                <strong>profil</strong>
                fournit quant à lui la structure c'est-à-dire une
                <strong>spécification détaillant une API</strong>
                . Le profil utilise une configuration.
                <br />
                Le profil est nécessaire pour fournir un environnement de fonctionnement complet pour un type d'appareil donné. Il fourni généralement l'interface utilisateur, les méthodes d'entrées-sorties et le mécanisme de persistance pour un groupe d'appareil. Il doit se suffire à lui même et ne pas nécessiter l'ajout d'autres classes java.
                <br />
                Toutefois certains profils peuvent être créés pour répondre à certaines capacités ou services d'appareils (RMI, multimédia,...).
                <br />
                Un appareil peut donc supporter plusieurs profils. L'implémentation du profil est à la charge du fabricant de l'appareil qui porte la JVM sur son matériel.
                <br />
                <br />
                <em>Il existe plusieurs profiles :</em>
                <br />
            </p>
            <table border="1">
                <tbody>
                    <tr>
                        <td>
                            <strong>
                                <u>PROFIL</u>
                            </strong>
                        </td>
                        <td>
                            <strong>
                                <u>CONFIGURATION</u>
                            </strong>
                        </td>
                        <td>
                            <strong>
                                <u>JSR</u>
                            </strong>
                        </td>
                        <td />
                    </tr>
                    <tr>
                        <td>MIDP 1.0</td>
                        <td>CLDC</td>
                        <td>37</td>
                        <td>Fournit un ensemble d'APIs (gestion de réseau y compris, stockage local, et interface utilisateur)</td>
                    </tr>
                    <tr>
                        <td>Foundation Profile</td>
                        <td>CDC</td>
                        <td>46</td>
                        <td>Profil bas dans la pile de CDC. API de gestion de réseau pour les dispositifs qui n'ont pas besoin de possibilités graphiques</td>
                    </tr>
                    <tr>
                        <td>Personal Profile</td>
                        <td>CDC</td>
                        <td>62</td>
                        <td>Prévu pour être (avec les profils au-dessous de lui dans la pile de CDC) le remplacement de J2ME de l'environnement de PersonalJava de Sun et fournit la compatibilité ces applications</td>
                    </tr>
                    <tr>
                        <td>MIPD 2.0</td>
                        <td>CLDC</td>
                        <td>118</td>
                        <td>API pour le jeu, le bruit, la sécurité, et un enregistrement de poussée en pile de MIDP</td>
                    </tr>
                    <tr>
                        <td>Personal Basis Profile</td>
                        <td>CDC</td>
                        <td>129</td>
                        <td>Construit sur le profil de base, ce profil fournit l'appui de base d'interface utilisateur et agit à la base pour le profil personnel</td>
                    </tr>
                    <tr>
                        <td>RMI optional Profile (Remote Method Invocation)</td>
                        <td>CDC</td>
                        <td>66</td>
                        <td />
                    </tr>
                    <tr>
                        <td>Mobile Media API (MMAPI)</td>
                        <td>CLDC</td>
                        <td>135</td>
                        <td>Une api simple et extensible pour commander des ressources de bruit et de multimédia sur un dispositif de CLCD/MIDP.</td>
                    </tr>
                    <tr>
                        <td>JDBC optional Profile</td>
                        <td>CDC</td>
                        <td>169</td>
                        <td />
                    </tr>
                    <tr>
                        <td>Wireless Messaging API (WMA) 1.1</td>
                        <td>CLDC</td>
                        <td>120</td>
                        <td>Une api pour accéder aux ressources sans fil de communication, telles que SMS, qui fonctionne avec n'importe quel profil de J2ME</td>
                    </tr>
                </tbody>
            </table>
            <br />
            <p>
                Sun propose deux
                <strong>profils</strong>
                de référence J2ME : le profil Foundation et le profil Mobile Information Device Profile (MIDP).
            </p>
            <div class="subChapter">
                <h3>4.1. Le profil « Foundation »</h3>
                <p>Le profil Foundation est destiné à la configuration CDC. Les développeurs qui utilisent ce profil ont accès à une implémentation complète des fonctionnalités de J2SE.</p>
            </div>
            <div class="subChapter">
                <h3>4.2. Le profil « MIDP » (Mobile Information Device Profile)</h3>
                <p>
                    Le profil
                    <strong>MIDP</strong>
                    est destiné à la configuration CLDC. Il prend en charge un nombre limité des classes de J2SE et définit des classes d'entrée/sortie et d'interface spécialisées pour une configuration CLDC.
                    <br />
                    Il existe aujourd’hui deux implémentations majeures de profiles MIDP. L’une destinée aux Assistants de type Palm Pilot (PalmOs) et l’autre, totalement générique, proposée par Sun comme implémentation de référence.
                    <br />
                    <u>Les API liées à MIDP :</u>
                </p>
                <table border="1">
                    <tbody>
                        <tr>
                            <td colspan="2">Liste des packages de CLDC</td>
                        </tr>
                        <tr>
                            <td>
                                <strong>javax.microedition.lcdui</strong>
                            </td>
                            <td>Fournit la gestion de l’interface utilisateur (contrôles, …)</td>
                        </tr>
                        <tr>
                            <td>
                                <strong>javax.microedition.midlet</strong>
                            </td>
                            <td>Socle technique destiné à gérer le cycle de vie des midlets</td>
                        </tr>
                        <tr>
                            <td>
                                <strong>javax.microedition.rms</strong>
                            </td>
                            <td>Base de données persistante légère</td>
                        </tr>
                    </tbody>
                </table>
                <p>
                    <u>Architecture J2ME :</u>
                    <br />
                    <img src="images/j2me_html_m612bd0c.jpg" width="100%" alt="" />
                    <br />
                    Cette multitude de profils peut engendrer un certain nombre de problème lors de l'exécution d'une application sur différents périphériques car il n'y a pas la certitude d'avoir à disposition les profils nécessaires.
                    <br />
                    Pour palier à ce problème, une spécification particulière issue des travaux de la JSR 185 et nommée Java Technology for the Wireless Industry (JTWI) a été développée. En effet, elle impose aux périphériques, qui la respectent, de mettre en oeuvre au minimum : CLDC 1.0, MIDP 2.0, Wireless Messaging API 1.1 (pour l'envoi et la réception de SMS) et Mobile Media API 1.1 (assure des fonctions de multimédia). Assurant ainsi, une meilleure compatibilité entre les applications et les différents téléphones mobiles sur lesquelles elles s'exécutent.
                    <br />
                    Pour savoir quelles machines supportent quels profils vous pouvez vous renseigner auprès des fabricants ou consulter la liste sur le site de Sun :
                    <a href="http://developers.sun.com/mobility/device/device?api=none" target="_blank">Liste de appareils supportant J2ME.</a>
                </p>
            </div>
        </div>
        <div class="chapter">
            <h2>5. Les Midlets</h2>
            <p>Les applications créées avec MIDP sont des midlets : ce sont des classes qui héritent de la classe abstraite javax.microedition.midlet.Midlet. Cette classe permet le dialogue entre le système et l'application.</p>
            <div class="subChapter">
                <h3>5.1. Les Midlets</h3>
                <p>
                    Elle possède trois méthodes qui permettent de gérer le cycle de vie de l'application en fonction des trois états possibles (active, suspendue ou détruite) :
                    <br />
                </p>
                <ul>
                    <li>startApp() : cette méthode est appelée à chaque démarrage ou redémarrage de l'application</li>
                    <li>pauseApp() : cette méthode est appelée lors de la mise en pause de l'application</li>
                    <li>destroyApp() : cette méthode est appelée lors de la destruction de l'application</li>
                </ul>
                <br />
                Le cycle de vie d'une midlet est semblable à celui d'une applet. Elle possède plusieurs états :
                <br />
                <ul>
                    <li>paused :</li>
                    <li>active :</li>
                    <li>destroyed :</li>
                </ul>
                <br />
                Le changement de l'état de la midlet peut être provoqué par l'environnement d'exécution ou la Midlet.
                <br />
                <img src="images/j2me_html_1a79b4e9.png" alt="" width="100%" />
            </div>
            <div class="subChapter">
                <h3>5.2. Un exemple de Midlet : Convertisseur Francs Euros</h3>
                <p>
                    Sun propose un outil pour développer des applications J2ME utilisant CLDC/MIDP. Cet outil peut être téléchargé
                    <a href="http://java.sun.com/products/sjwtoolkit/index.html" target="_blank">ici</a>
                    .
                    <a href="http://java.sun.com/products/sjwtoolkit/download-2_2.html" target="_bank">Téléchargez</a>
                    le et installez le. A noter cependant que le
                    <a href="http://developers.sun.com/downloads/" target="_blank">JDK standard</a>
                    de Sun doit être installé au préalable.
                    <br />
                    Lancez le programme KToolbar, la fenêtre ci-dessous apparaît.
                    <br />
                    <img src="images/j2me_html_m27de4391.png" width="100%" />
                    <br />
                    Cliquez sur "
                    <em>New Project</em>
                    ", et inscrivez dans les deux champs proposés "
                    <em>Convertisseur</em>
                    " qui sera le nom de notre projet.
                    <br />
                    A la fenêtre suivante, "
                    <em>Settings for project Convertisseur</em>
                    ", Choisissez "
                    <em>CLDC 1.1</em>
                    " puis cliquez sur "
                    <em>OK</em>
                    ". Un nouveau répertoire a été créé et la console en indique le chemin.
                    <br />
                    Rendez-vous dans le répertoire du projet, il contient plusieurs dossiers dont un dossier "
                    <em>src</em>
                    ", créez dans ce dossier "
                    <em>src</em>
                    " un fichier appelé "
                    <em>Convertisseur.java</em>
                    ", éditez le avec un éditeur de texte comme le Bloc-Notes placez-y le code suivant :
                    <br />
                    <textarea name="code" class="java">/*
						* Convertisseur.java 1.2 31/05/06
						*
						*/
						import javax.microedition.midlet.*;
						import javax.microedition.lcdui.*;
						public final class Convertisseur extends MIDlet implements CommandListener {
						/** Nombre de chiffre possible ds le champ text **/
						private static final int NUM_SIZE=20;
						/** Boutton Exit **/
						private final Command exitCmd = new Command("Exit", Command.EXIT, 2);
						/** Boutton Calcul **/
						private final Command calcCmd = new Command("Calc", Command.SCREEN,1);
						private final ChoiceGroup euroFrcs = new ChoiceGroup ("", ChoiceGroup.POPUP, new String[] {" En Francs:", "En Euros:"}, null);
						/** Champ éditable **/
						private final TextField aConvertir = new TextField(null, "", NUM_SIZE, TextField.DECIMAL);
						private final TextField Result = new TextField(null, "", NUM_SIZE, TextField.UNEDITABLE);
						private final Alert alert = new Alert ("Error", "", null, AlertType.ERROR);
						private final double euro = 6.559;
						/** Indique si l'applacation est lancée **/
						private boolean isInitialized = false;
						protected void startApp(){
						if(isInitialized){return;}
						/* creation d'un objet formulaire sur lequel on peut placer des composants */
						Form myForm = new Form("Convertisseur Frcs-Euro");
						/* Ajout des composant au formulaie */
						myForm.append("Somme à convertir :");
						myForm.append(aConvertir);
						myForm.append(euroFrcs);
						myForm.append("Résultat = ");
						myForm.append(Result);
						myForm.addCommand(exitCmd);
						myForm.addCommand(calcCmd);
						myForm.setCommandListener(this);
						Display.getDisplay(this).setCurrent(myForm);
						alert.addCommand(new Command("Back", Command.SCREEN, 1));
						isInitialized =true;
						}
						protected void destroyApp(boolean unconditional) {}
						protected void pauseApp() {}
						public void commandAction(Command c, Displayable d){
						/* lors du clic sur le bouton Exit */
						if(c == exitCmd){
						/* appel manuel à la fonction de fermeture */
						destroyApp(false);
						notifyDestroyed();
						return;
						}
						/* Note: c'est à partir de la CLDC 1.1 que le type "float" est reconnu */
						double res = 0.0;
						try{
						double n1 = getNumber(aConvertir, "First");
						/** Euro-&gt;Francs ou Francs-&gt;Euro **/
						switch (euroFrcs.getSelectedIndex())
						{
						case 0: res = n1 * euro; break;
						case 1: res = n1/euro; break;
						default:
						}
						}catch(NumberFormatException e){return;}
						String res_str = Double.toString(res);
						/* On adapte la taille de la fenêtre Result en fonction du résultat*/ if(res_str.length()&gt; Result.getMaxSize()){
						Result.setMaxSize(res_str.length());
						}
						/* Affichage du résultat */
						Result.setString (res_str);
						}
						/** Methode permettant d'effectuer des tests sur le nombre à convertir **/
						private double getNumber(TextField t, String type)
						throws NumberFormatException {
						String s = t.getString();
						/* On test si le champ Somme à convertir est rempli */
						if (s.length() == 0) {
						alert.setString("No " + type + " Argument");
						Display.getDisplay(this).setCurrent(alert);
						throw new NumberFormatException();
						}
						double n;
						try {
						n = Double.parseDouble(s);
						/* On test si le nombre est positif */
						if(n
						&lt;0)
						{
						Display.getDisplay(this).setCurrent(alert);
						throw new NumberFormatException();
						}
						}catch (NumberFormatException e) {
						alert.setString(type + " argument is out of range.");
						Display.getDisplay(this).setCurrent(alert);
						throw e;
						}
						return n;
						}</textarea>
                    <br />
                    <u>Analysons un peu ce code :</u>
                    <br />
                    Tout d’abord on commence avec l’importation des 2 packages javax.microedition.midlet qui fournit des classes pour la gestion de vie des midlets et
					javax.microedition.lcdui package utile pour l’IHM (Interface Homme/machine).
                    <br />
                    <br />
                    La première partie permet de définir des contrôles et composants graphiques :
					La classe Command permet de définir des boutons à l’intérieur de notre application.
					Une commande (
                    <strong>Command</strong>
                    ) encapsule à la fois le nom (ce qui est affiché), le type (intention de la commande comme BACK, CANCEL, OK) et la priorité d'une action.
					La classe ChoiceGroup permet de définir une sélection d'un ou plusieurs éléments.
					La classe TextField permet de définir un composant de saisie de texte.
					Ses deux classes héritent de la classe javax.microedition.lcdui.Item.
                    <br />
                    <br />
                    La classe Alert permet d’afficher une boîte de dialogue pendant un temps déterminé.
					Elle possède deux constructeurs :
                    <br />
                </p>
                <ul>
                    <li>un demandant le titre de l'objet</li>
                    <li>un demandant le titre, le texte, l'image et le type de l'image</li>
                </ul>
                <br />
                AlertType.ERROR permet d’informer à l’utilisateur d’une erreur.
                <br />
                <br />
                La méthode startApp() est appelée lors du démarrage ou redémarrage de la midlet.
                <br />
                La méthode pauseApp() est appelée lors de mise en pause de la midlet.
                <br />
                La méthode destroyApp() est appelée juste avant la destruction de la midlet
                <br />
                <br />
                Une midlet active a normalement accès à l'écran. Celui ci est représenté par la classe Display et l'unique instance de cette classe est obtenue en appelant Display.getDisplay(m) où m est la midlet
				La midlet peut changer l'objet afficher avec Display.setCurrent.
                <br />
                <br />
                La méthode commandAction() dans l'objet callback (listener) prend en argument la commande
                <strong>Command</strong>
                et l'objet activé
                <strong>Displayable</strong>
                .
                <br />
                <br />
                Pour construire le projet, il faut cliquer sur le bouton "
                <em>Build</em>
                "
                <br />
                <img src="images\j2me_html_m5fbbd4e6.png" alt="" />
                <br />
                <br />
                Pour exécuter le projet, il suffit de choisir le type d'émulateur à utiliser et cliquer sur le bouton "
                <em>Run</em>
                ".
                <br />
                Deux fichiers importants (Convertisseur.jar et Convertisseur.jad) sont générés dans le répertoire "
                <em>bin</em>
                ".
                <br />
                <br />
                <u>Exemple</u>
                : avec l'émulateur de téléphone par défaut.
                <br />
                <br />
                <img src="images/j2me_html_m7c59158.png" alt="" />
                <br />
                <img src="images/j2me_html_3f3c1c0f.png" alt="" />
            </div>
        </div>
        <div class="chapter">
            <h2>6. Conclusion</h2>
            <p>
                Cette plateforme J2ME est donc un puissant outil pour la programmation des téléphones mobiles. Nul doute que cette technologie s’affinera au cours des prochaines années.
                <br />
                D’autant plus que Java n’est pas le seul sur ce marché en pleine expansion, en effet, Microsoft est lui aussi présent.
                <br />
                Sur ce marché de l'embarqué, Sun possède des alliés de poids en la personne d'IBM ou d'Oracle. Quant aux constructeurs, les alliances se forment à tout va avec Nokia, Motorola, Siemens ou Sony. Il faudra beaucoup d'énergie à Microsoft pour arriver à remporter des batailles sur un marché hautement stratégique et promis à un bel avenir.
            </p>
        </div>
    </body>
</html>

